import request from '@/utils/request'
import config from '@/config'
import { getToken } from '@/utils/auth'

/**
 * 文件上传配置接口
 * @typedef {Object} UploadConfig
 * @property {number} maxSize - 最大文件大小（字节）
 * @property {number} maxFileNameLength - 最大文件名长度
 * @property {string[]} allowedTypes - 允许的文件类型
 * @property {string} uploadUrl - 上传接口路径
 * @property {Function} getHeaders - 获取请求头的函数
 */

/**
 * 文件数据接口
 * @typedef {Object} FileData
 * @property {string} tempFilePath - 临时文件路径
 * @property {string} name - 文件名
 * @property {number} size - 文件大小
 * @property {number} [duration] - 视频时长（秒）
 */

/**
 * 通用文件上传配置
 * @type {UploadConfig}
 */
const UPLOAD_CONFIG = {
  // 默认配置
  maxSize: 50 * 1024 * 1024, // 50MB
  maxFileNameLength: 100,
  allowedTypes: [
    'bmp', 'gif', 'jpg', 'jpeg', 'png', 'doc', 'docx', 
    'xls', 'xlsx', 'ppt', 'pptx', 'html', 'htm', 'txt', 
    'rar', 'zip', 'gz', 'bz2', 'mp4', 'avi', 'rmvb', 'pdf'
  ],
  // 上传接口配置
  uploadUrl: '/common/uploadMinio',
  // 请求头配置
  getHeaders: () => ({
    'Authorization': 'Bearer ' + getToken()
  })
}

/**
 * 通用文件上传接口（完整版）
 * @param {Object} options - 上传选项
 * @param {Object} options.fileData - 文件数据
 * @param {Function} options.onProgress - 上传进度回调
 * @param {Object} options.config - 自定义配置
 * @returns {Promise} 返回完整的上传结果
 */
export function uploadFile(options = {}) {
  const { fileData, onProgress, config = {} } = options
  
  return new Promise((resolve, reject) => {
    // 合并配置
    const finalConfig = { ...UPLOAD_CONFIG, ...config }
    
    // 验证文件
    const validation = validateFile(fileData, finalConfig)
    if (!validation.isValid) {
      reject({
        code: 500,
        msg: validation.errors[0]
      })
      return
    }

    // 构建上传URL
    const baseURL = config.baseURL || config.baseUrl || 'http://localhost:8080'
    const uploadUrl = baseURL + finalConfig.uploadUrl
    
    console.log('上传URL:', uploadUrl)
    console.log('文件路径:', fileData.tempFilePath || fileData.path)
    
    const token = getToken()
    
    // 检查token是否存在
    if (!token) {
      reject({
        code: 401,
        msg: '未找到认证token，请重新登录'
      })
      return
    }

    // 使用uni.uploadFile进行上传
    const uploadTask = uni.uploadFile({
      url: uploadUrl,
      filePath: fileData.tempFilePath || fileData.path,
      name: 'file',
      header: finalConfig.getHeaders(),
      success: (uploadRes) => {
        try {
          const result = JSON.parse(uploadRes.data)
          if (result.code === 200) {
            resolve({
              code: 200,
              msg: result.msg || '上传成功',
              url: result.url,
              fileName: result.fileName,
              newFileName: result.newFileName,
              originalFileName: result.originalFileName,
              data: result.data // 保留原始数据
            })
          } else {
            reject({
              code: result.code || 500,
              msg: result.msg || '上传失败'
            })
          }
        } catch (e) {
          reject({
            code: 500,
            msg: '响应数据解析失败'
          })
        }
      },
      fail: (error) => {
        reject({
          code: 500,
          msg: `网络异常，请检查网络连接后重试。错误信息：${error.errMsg || error.message || '未知错误'}`
        })
      }
    })

    // 监听上传进度
    if (onProgress && typeof onProgress === 'function') {
      uploadTask.onProgressUpdate((progress) => {
        onProgress(progress.progress)
      })
    }
  })
}

/**
 * 简化文件上传接口（只返回URL）
 * @param {Object} fileData - 文件数据
 * @param {Function} onProgress - 上传进度回调
 * @param {Object} config - 自定义配置
 * @returns {Promise} 只返回URL字符串
 */
export function uploadFileSimple(fileData, onProgress, config = {}) {
  return uploadFile({ fileData, onProgress, config }).then(result => result.url)
}

/**
 * 批量上传文件（完整版）
 * @param {Array} fileList - 文件列表
 * @param {Function} onProgress - 整体进度回调
 * @param {Object} config - 自定义配置
 * @returns {Promise} 返回完整的上传结果数组
 */
export function batchUploadFile(fileList, onProgress, config = {}) {
  return new Promise((resolve, reject) => {
    if (!fileList || fileList.length === 0) {
      reject({
        code: 500,
        msg: '文件列表为空'
      })
      return
    }

    const results = []
    let completedCount = 0
    let hasError = false

    fileList.forEach((fileData, index) => {
      uploadFile({ fileData, config }, (progress) => {
        // 计算整体进度
        const totalProgress = Math.round((completedCount + progress / 100) / fileList.length * 100)
        if (onProgress) {
          onProgress(totalProgress, index, progress)
        }
      }).then(result => {
        results[index] = result
        completedCount++
        
        if (completedCount === fileList.length) {
          if (hasError) {
            reject({
              code: 500,
              msg: '部分文件上传失败',
              results: results
            })
          } else {
            resolve({
              code: 200,
              msg: '批量上传成功',
              results: results
            })
          }
        }
      }).catch(error => {
        results[index] = error
        hasError = true
        completedCount++
        
        if (completedCount === fileList.length) {
          reject({
            code: 500,
            msg: '部分文件上传失败',
            results: results
          })
        }
      })
    })
  })
}

/**
 * 批量上传文件（简化版，只返回URL数组）
 * @param {Array} fileList - 文件列表
 * @param {Function} onProgress - 整体进度回调
 * @param {Object} config - 自定义配置
 * @returns {Promise} 只返回URL数组
 */
export function batchUploadFileSimple(fileList, onProgress, config = {}) {
  return batchUploadFile(fileList, onProgress, config).then(result => 
    result.results.map(r => r.url)
  )
}

/**
 * 视频上传专用接口（简化版）
 * @param {Object} videoData - 视频数据
 * @param {Function} onProgress - 上传进度回调
 * @param {Object} config - 自定义配置
 * @returns {Promise} 返回视频URL
 */
export function uploadVideo(videoData, onProgress, config = {}) {
  // 视频专用配置
  const videoConfig = {
    ...config,
    baseUrl: config.baseUrl || config.baseURL || config.baseUrl || 'http://localhost:8080',
    maxSize: config.maxSize || 100 * 1024 * 1024, // 视频默认100MB
    allowedTypes: config.allowedTypes || [
      'mp4', 'avi', 'mov', 'wmv', 'flv', 'webm', 'mkv', 'm4v', 
      '3gp', 'ogv', 'ts', 'mts', 'm2ts'
    ]
  }
  
  console.log('uploadVideo配置:', videoConfig)
  return uploadFileSimple(videoData, onProgress, videoConfig)
}

/**
 * 图片上传专用接口（简化版）
 * @param {Object} imageData - 图片数据
 * @param {Function} onProgress - 上传进度回调
 * @param {Object} config - 自定义配置
 * @returns {Promise} 返回图片URL
 */
export function uploadImage(imageData, onProgress, config = {}) {
  // 图片专用配置
  const imageConfig = {
    ...config,
    allowedTypes: config.allowedTypes || ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp']
  }
  
  return uploadFileSimple(imageData, onProgress, imageConfig)
}

/**
 * 文档上传专用接口（简化版）
 * @param {Object} docData - 文档数据
 * @param {Function} onProgress - 上传进度回调
 * @param {Object} config - 自定义配置
 * @returns {Promise} 返回文档URL
 */
export function uploadDocument(docData, onProgress, config = {}) {
  // 文档专用配置
  const docConfig = {
    ...config,
    allowedTypes: config.allowedTypes || ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt']
  }
  
  return uploadFileSimple(docData, onProgress, docConfig)
}

/**
 * 检查文件是否有效
 * @param {FileData} fileData - 文件数据
 * @param {UploadConfig} config - 验证配置
 * @returns {{isValid: boolean, errors: string[]}} 检查结果
 */
export function validateFile(fileData, config = UPLOAD_CONFIG) {
  const errors = []

  // 检查文件大小
  if (fileData.size && fileData.size > config.maxSize) {
    const maxSizeMB = Math.round(config.maxSize / 1024 / 1024)
    errors.push(`文件大小超出限制，当前：${Math.round(fileData.size / 1024 / 1024)}MB，最大支持：${maxSizeMB}MB`)
  }

  // 检查文件名长度
  if (fileData.name && fileData.name.length > config.maxFileNameLength) {
    errors.push(`文件名长度超出限制，当前：${fileData.name.length}字符，最大支持：${config.maxFileNameLength}字符`)
  }

  // 检查文件类型
  let fileExtension = ''
  if (fileData.name) {
    const nameParts = fileData.name.split('.')
    if (nameParts.length > 1) {
      fileExtension = nameParts.pop().toLowerCase()
    }
  }
  
  // 如果文件名没有扩展名，尝试从tempFilePath推断
  if (!fileExtension && fileData.tempFilePath) {
    const tempFileName = fileData.tempFilePath.split('/').pop()
    const tempParts = tempFileName.split('.')
    if (tempParts.length > 1) {
      fileExtension = tempParts.pop().toLowerCase()
    }
  }
  
  // 如果仍然没有扩展名，默认使用mp4（视频文件）
  if (!fileExtension) {
    fileExtension = 'mp4'
  }
  
  // 检查文件类型
  if (!config.allowedTypes.includes(fileExtension)) {
    errors.push(`文件类型不支持，当前类型：${fileExtension}，支持的类型：${config.allowedTypes.join(', ')}`)
  }

  return {
    isValid: errors.length === 0,
    errors: errors
  }
}

/**
 * 创建自定义上传配置
 * @param {Object} customConfig - 自定义配置
 * @returns {Object} 合并后的配置
 */
export function createUploadConfig(customConfig = {}) {
  return { ...UPLOAD_CONFIG, ...customConfig }
}

// 兼容性导出（保持向后兼容）
export const uploadToMinio = uploadFile
export const batchUploadToMinio = batchUploadFile